package demo.day11

// Kotlin out协变
fun main() {
    val p1: Producer<Animal> = ProducerClass1() //ProducerClass1 本来传递Animal 当然是可以的
    val p2: Producer<Animal> = ProducerClass2() //ProducerClass2 本来传递的是Humanity 居然也是可以的 因为out
    val p3: Producer<Animal> = ProducerClass3() //ProducerClass3 本来传递的是Man 居然也是可以的 因为out
    val p4: Producer<Animal> = ProducerClass4() //ProducerClass2 本来传递的是Woman 居然也是可以的 因为out
    // 总结 默认情况下 泛型子类对象不可以赋值给泛型的父类对象 但是 out：泛型子类对象 可以赋值给泛型的父类对象
    // 泛型默认情况下是：泛型具体处的子类对象 不可以赋值给 泛型的父类对象
    // 泛型具体处的子类对象 不可以赋值给 泛型声明处的父类对象

    // out: 泛型的子类对象 可以赋值给 泛型的父类对象
    // 泛型具体处的子类对象 可以赋值给 泛型声明处的父类对象
    // 协变：父类 泛型声明处 可以接受 子类 泛型具体处

    val p11: Consumer<Animal> = ConsumerClass1()
    val p22: Consumer<Humanity> = ConsumerClass1()
    val p33: Consumer<Woman> = ConsumerClass1()
    val p44: Consumer<Man> = ConsumerClass1()
    // 默认情况下 泛型的具体处的父类 是不可以赋值给 泛型声明处的子类的
    // in 泛型具体的父类是可以赋值给泛型声明处的子类的
    // 逆变 子类泛型声明处 可以接收 父类 泛型具体处

    // 协变 out 父类 = 子类 （子类赋值给父类）
    // 逆变 in  子类 = 父类 （父类赋值给子类）


}

open class Animal // 动物
open class Humanity : Animal() // 人类
open class Man : Humanity() //男人
open class Woman : Humanity() //女人

// 生产者 协变
interface Producer<out T> {
    // out T 代表整个生产者里面这个T只能被读取 不能被修改
//    fun consumer(item:T){}
    // 只能被读取
    fun producer(): T
}

// 消费者 逆变
interface Consumer<in T> {
    // in T 只能被修改 不能被读取
    fun consumer(item: T)
//    fun producer():T
}

// 不变
interface ProducerAndConsumer<T> {
    fun consumer(item: T) {}
    fun producer(): T
}

class ConsumerClass1 : Consumer<Animal> {
    override fun consumer(item: Animal) {
        println("消费者 Animal")
    }

}

class ConsumerClass2 : Consumer<Humanity> {
    override fun consumer(item: Humanity) {
        println("消费者 Humanity")
    }
}

class ConsumerClass3 : Consumer<Man> {
    override fun consumer(item: Man) {
        println("消费者 Man")
    }
}

class ConsumerClass4 : Consumer<Woman> {
    override fun consumer(item: Woman) {
        println("消费者 Woman")
    }

}

class ProducerClass1 : Producer<Animal> {
    override fun producer(): Animal {
        println("生产者 Animal")
        return Animal()
    }
}

class ProducerClass2 : Producer<Humanity> {
    override fun producer(): Humanity {
        println("生产者 Humanity")
        return Humanity()
    }
}

class ProducerClass3 : Producer<Man> {
    override fun producer(): Man {
        println("生产者 Man")
        return Man()
    }
}

class ProducerClass4 : Producer<Woman> {
    override fun producer(): Woman {
        println("生产者 Woman")
        return Woman()
    }
}